diff --git a/user_guide/changelog.html b/user_guide/changelog.html
index e8de98f..554d587 100644
--- a/user_guide/changelog.html
+++ b/user_guide/changelog.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Change Log</title>
 
 <style type='text/css' media='all'>@import url('userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='userguide.css' />
diff --git a/user_guide/database/active_record.html b/user_guide/database/active_record.html
index 59a8005..37629ae 100644
--- a/user_guide/database/active_record.html
+++ b/user_guide/database/active_record.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Active Record</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/database/caching.html b/user_guide/database/caching.html
index fa67a52..ac0c354 100644
--- a/user_guide/database/caching.html
+++ b/user_guide/database/caching.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Database Caching Class</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/database/call_function.html b/user_guide/database/call_function.html
index 1e891d1..dc6ae50 100644
--- a/user_guide/database/call_function.html
+++ b/user_guide/database/call_function.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Custom Function Calls</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/database/configuration.html b/user_guide/database/configuration.html
index c97e93f..09e1b56 100644
--- a/user_guide/database/configuration.html
+++ b/user_guide/database/configuration.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Database Configuration</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/database/connecting.html b/user_guide/database/connecting.html
index 0586c5d..849c806 100644
--- a/user_guide/database/connecting.html
+++ b/user_guide/database/connecting.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Connecting to your Database</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/database/examples.html b/user_guide/database/examples.html
index 31893e4..f1deda2 100644
--- a/user_guide/database/examples.html
+++ b/user_guide/database/examples.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Database Quick Start</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/database/fields.html b/user_guide/database/fields.html
index 3b4978d..f200bbc 100644
--- a/user_guide/database/fields.html
+++ b/user_guide/database/fields.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Field Data</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/database/helpers.html b/user_guide/database/helpers.html
index e9bc4a2..4dfc07b 100644
--- a/user_guide/database/helpers.html
+++ b/user_guide/database/helpers.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Query Helper Functions</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/database/index.html b/user_guide/database/index.html
index 39bd605..c99b571 100644
--- a/user_guide/database/index.html
+++ b/user_guide/database/index.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : The Database Class</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/database/queries.html b/user_guide/database/queries.html
index 6c94f4c..3778e28 100644
--- a/user_guide/database/queries.html
+++ b/user_guide/database/queries.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Queries</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/database/results.html b/user_guide/database/results.html
index fedbc11..c4583fb 100644
--- a/user_guide/database/results.html
+++ b/user_guide/database/results.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Generating Query Results</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/database/table_data.html b/user_guide/database/table_data.html
index e848372..e1ac607 100644
--- a/user_guide/database/table_data.html
+++ b/user_guide/database/table_data.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Table Data</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/database/transactions.html b/user_guide/database/transactions.html
index cf41f95..5ecede8 100644
--- a/user_guide/database/transactions.html
+++ b/user_guide/database/transactions.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Transactions</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/database/utilities.html b/user_guide/database/utilities.html
index 801dc2d..7fe6c02 100644
--- a/user_guide/database/utilities.html
+++ b/user_guide/database/utilities.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Database Utility Class</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/alternative_php.html b/user_guide/general/alternative_php.html
index 579ae4c..1d10a4e 100644
--- a/user_guide/general/alternative_php.html
+++ b/user_guide/general/alternative_php.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Alternate PHP Syntax for View Files</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/ancillary_classes.html b/user_guide/general/ancillary_classes.html
index e13f021..b752ac3 100644
--- a/user_guide/general/ancillary_classes.html
+++ b/user_guide/general/ancillary_classes.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Creating Ancillary Classes</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/autoloader.html b/user_guide/general/autoloader.html
index 4c910a8..55b3c0d 100644
--- a/user_guide/general/autoloader.html
+++ b/user_guide/general/autoloader.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Auto-loading Resources</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/caching.html b/user_guide/general/caching.html
index c8e5f58..6c7d35f 100644
--- a/user_guide/general/caching.html
+++ b/user_guide/general/caching.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Web Page Caching</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/controllers.html b/user_guide/general/controllers.html
index 9e2ec0a..3d0f850 100644
--- a/user_guide/general/controllers.html
+++ b/user_guide/general/controllers.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Controllers</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/core_classes.html b/user_guide/general/core_classes.html
index 20641cf..2260de6 100644
--- a/user_guide/general/core_classes.html
+++ b/user_guide/general/core_classes.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Creating Core System Classes</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/creating_libraries.html b/user_guide/general/creating_libraries.html
index b2c6632..ebdb1ee 100644
--- a/user_guide/general/creating_libraries.html
+++ b/user_guide/general/creating_libraries.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Creating Libraries</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/credits.html b/user_guide/general/credits.html
index 87f058a..a1dba42 100644
--- a/user_guide/general/credits.html
+++ b/user_guide/general/credits.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Credits</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/errors.html b/user_guide/general/errors.html
index 9e78bfd..f6e8e1c 100644
--- a/user_guide/general/errors.html
+++ b/user_guide/general/errors.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Error Handling</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/helpers.html b/user_guide/general/helpers.html
index 50bd34c..d5cd07a 100644
--- a/user_guide/general/helpers.html
+++ b/user_guide/general/helpers.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Helper Functions</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/hooks.html b/user_guide/general/hooks.html
index daf99e8..edcf431 100644
--- a/user_guide/general/hooks.html
+++ b/user_guide/general/hooks.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Hooks</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/index.html b/user_guide/general/index.html
index 525db5b..0135a2b 100644
--- a/user_guide/general/index.html
+++ b/user_guide/general/index.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Getting Started With CodeIgniter</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/libraries.html b/user_guide/general/libraries.html
index 5f59e73..5d1049e 100644
--- a/user_guide/general/libraries.html
+++ b/user_guide/general/libraries.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Using CodeIgniter Libraries</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/managing_apps.html b/user_guide/general/managing_apps.html
index 80567a1..aabb2f8 100644
--- a/user_guide/general/managing_apps.html
+++ b/user_guide/general/managing_apps.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Managing your Applications</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/models.html b/user_guide/general/models.html
index 901862a..f2a6761 100644
--- a/user_guide/general/models.html
+++ b/user_guide/general/models.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Models</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/plugins.html b/user_guide/general/plugins.html
index 51b5192..fc5a01e 100644
--- a/user_guide/general/plugins.html
+++ b/user_guide/general/plugins.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Plugins</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/profiling.html b/user_guide/general/profiling.html
index 5e874f4..8e61600 100644
--- a/user_guide/general/profiling.html
+++ b/user_guide/general/profiling.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Profiling Your Application</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/quick_reference.html b/user_guide/general/quick_reference.html
index a1e2b51..8177fe7 100644
--- a/user_guide/general/quick_reference.html
+++ b/user_guide/general/quick_reference.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Quick Reference Chart</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/requirements.html b/user_guide/general/requirements.html
index a718199..d676093 100644
--- a/user_guide/general/requirements.html
+++ b/user_guide/general/requirements.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Server Requirements</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/routing.html b/user_guide/general/routing.html
index 0ae2e4c..8872d4c 100644
--- a/user_guide/general/routing.html
+++ b/user_guide/general/routing.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : URI Routing</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/scaffolding.html b/user_guide/general/scaffolding.html
index c9325b9..a72a85b 100644
--- a/user_guide/general/scaffolding.html
+++ b/user_guide/general/scaffolding.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Scaffolding</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/security.html b/user_guide/general/security.html
index 942fb73..6396e9a 100644
--- a/user_guide/general/security.html
+++ b/user_guide/general/security.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Security</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/urls.html b/user_guide/general/urls.html
index 4bacfa4..b0cc52b 100644
--- a/user_guide/general/urls.html
+++ b/user_guide/general/urls.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : CodeIgniter URLs</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/general/views.html b/user_guide/general/views.html
index 03fc7a4..e2a209e 100644
--- a/user_guide/general/views.html
+++ b/user_guide/general/views.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Views</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/helpers/array_helper.html b/user_guide/helpers/array_helper.html
index adf532e..77d3319 100644
--- a/user_guide/helpers/array_helper.html
+++ b/user_guide/helpers/array_helper.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Array Helper</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/helpers/cookie_helper.html b/user_guide/helpers/cookie_helper.html
index 0f5411a..c65f3c2 100644
--- a/user_guide/helpers/cookie_helper.html
+++ b/user_guide/helpers/cookie_helper.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Cookie Helper</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/helpers/date_helper.html b/user_guide/helpers/date_helper.html
index 7850faf..d703801 100644
--- a/user_guide/helpers/date_helper.html
+++ b/user_guide/helpers/date_helper.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Date Helper</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/helpers/directory_helper.html b/user_guide/helpers/directory_helper.html
index 3f89fd3..0bffd5b 100644
--- a/user_guide/helpers/directory_helper.html
+++ b/user_guide/helpers/directory_helper.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Directory Helper</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/helpers/download_helper.html b/user_guide/helpers/download_helper.html
index e19ad1a..45bceb2 100644
--- a/user_guide/helpers/download_helper.html
+++ b/user_guide/helpers/download_helper.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Download Helper</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/helpers/file_helper.html b/user_guide/helpers/file_helper.html
index f3654ed..4d2f8bf 100644
--- a/user_guide/helpers/file_helper.html
+++ b/user_guide/helpers/file_helper.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : File Helper</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/helpers/form_helper.html b/user_guide/helpers/form_helper.html
index 599d86c..d9eeb21 100644
--- a/user_guide/helpers/form_helper.html
+++ b/user_guide/helpers/form_helper.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Form Helper</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/helpers/html_helper.html b/user_guide/helpers/html_helper.html
index e7affb0..096c6f9 100644
--- a/user_guide/helpers/html_helper.html
+++ b/user_guide/helpers/html_helper.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : HTML Helper</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/helpers/index.html b/user_guide/helpers/index.html
index 5814e62..729a56a 100644
--- a/user_guide/helpers/index.html
+++ b/user_guide/helpers/index.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Helper Functions</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/helpers/inflector_helper.html b/user_guide/helpers/inflector_helper.html
index 0888299..5329901 100644
--- a/user_guide/helpers/inflector_helper.html
+++ b/user_guide/helpers/inflector_helper.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Inflector Helper</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/helpers/security_helper.html b/user_guide/helpers/security_helper.html
index 0826491..e2e6c9b 100644
--- a/user_guide/helpers/security_helper.html
+++ b/user_guide/helpers/security_helper.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Security Helper</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/helpers/smiley_helper.html b/user_guide/helpers/smiley_helper.html
index 528c91c..dd28882 100644
--- a/user_guide/helpers/smiley_helper.html
+++ b/user_guide/helpers/smiley_helper.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Smiley Helper</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/helpers/string_helper.html b/user_guide/helpers/string_helper.html
index 1fb5514..cf68717 100644
--- a/user_guide/helpers/string_helper.html
+++ b/user_guide/helpers/string_helper.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : String Helper</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/helpers/text_helper.html b/user_guide/helpers/text_helper.html
index 190352d..b77bc48 100644
--- a/user_guide/helpers/text_helper.html
+++ b/user_guide/helpers/text_helper.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Text Helper</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/helpers/typography_helper.html b/user_guide/helpers/typography_helper.html
index 388e4ce..15f852f 100644
--- a/user_guide/helpers/typography_helper.html
+++ b/user_guide/helpers/typography_helper.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Typography Helper</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/helpers/url_helper.html b/user_guide/helpers/url_helper.html
index 7606c7a..0f60755 100644
--- a/user_guide/helpers/url_helper.html
+++ b/user_guide/helpers/url_helper.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : URL Helper</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/helpers/xml_helper.html b/user_guide/helpers/xml_helper.html
index 78fa2bc..afed3e6 100644
--- a/user_guide/helpers/xml_helper.html
+++ b/user_guide/helpers/xml_helper.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : XML Helper</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/index.html b/user_guide/index.html
index ab1f85f..3d7f7fd 100644
--- a/user_guide/index.html
+++ b/user_guide/index.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Welcome to CodeIgniter</title>
 
 <style type='text/css' media='all'>@import url('userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='userguide.css' />
diff --git a/user_guide/installation/downloads.html b/user_guide/installation/downloads.html
index 983bf98..939437e 100644
--- a/user_guide/installation/downloads.html
+++ b/user_guide/installation/downloads.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Downloading CodeIgniter</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/installation/index.html b/user_guide/installation/index.html
index 4d54333..13a9c11 100644
--- a/user_guide/installation/index.html
+++ b/user_guide/installation/index.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Installation Instructions</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/installation/troubleshooting.html b/user_guide/installation/troubleshooting.html
index d7858af..c5517a7 100644
--- a/user_guide/installation/troubleshooting.html
+++ b/user_guide/installation/troubleshooting.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Troubleshooting</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/installation/upgrade_154.html b/user_guide/installation/upgrade_154.html
index 3d8d1ba..1494f5a 100644
--- a/user_guide/installation/upgrade_154.html
+++ b/user_guide/installation/upgrade_154.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Upgrading from 1.5.3 to 1.5.4</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/installation/upgrading.html b/user_guide/installation/upgrading.html
index 182953c..9434e02 100644
--- a/user_guide/installation/upgrading.html
+++ b/user_guide/installation/upgrading.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Upgrading From a Previous Version</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/libraries/benchmark.html b/user_guide/libraries/benchmark.html
index 6365c1c..59605e7 100644
--- a/user_guide/libraries/benchmark.html
+++ b/user_guide/libraries/benchmark.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Benchmarking Class</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/libraries/calendar.html b/user_guide/libraries/calendar.html
index 275d750..2880887 100644
--- a/user_guide/libraries/calendar.html
+++ b/user_guide/libraries/calendar.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Calendaring Class</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/libraries/config.html b/user_guide/libraries/config.html
index e0ba05f..6fca8ec 100644
--- a/user_guide/libraries/config.html
+++ b/user_guide/libraries/config.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Config Class</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/libraries/email.html b/user_guide/libraries/email.html
index 9583de2..d8d5065 100644
--- a/user_guide/libraries/email.html
+++ b/user_guide/libraries/email.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Email Class</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/libraries/encryption.html b/user_guide/libraries/encryption.html
index 0504ac8..6bb46b9 100644
--- a/user_guide/libraries/encryption.html
+++ b/user_guide/libraries/encryption.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Encryption Class</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/libraries/file_uploading.html b/user_guide/libraries/file_uploading.html
index 2c0e4ec..810338d 100644
--- a/user_guide/libraries/file_uploading.html
+++ b/user_guide/libraries/file_uploading.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : File Uploading Class</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/libraries/ftp.html b/user_guide/libraries/ftp.html
index 5520b51..aa61ed3 100644
--- a/user_guide/libraries/ftp.html
+++ b/user_guide/libraries/ftp.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : FTP Class</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/libraries/image_lib.html b/user_guide/libraries/image_lib.html
index 1814f43..982999a 100644
--- a/user_guide/libraries/image_lib.html
+++ b/user_guide/libraries/image_lib.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Image Manipulation Class</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/libraries/input.html b/user_guide/libraries/input.html
index 480cb6b..05a6a0b 100644
--- a/user_guide/libraries/input.html
+++ b/user_guide/libraries/input.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Input Class</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/libraries/language.html b/user_guide/libraries/language.html
index 99b5078..67af48c 100644
--- a/user_guide/libraries/language.html
+++ b/user_guide/libraries/language.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Language Class</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/libraries/loader.html b/user_guide/libraries/loader.html
index 28f9564..228f865 100644
--- a/user_guide/libraries/loader.html
+++ b/user_guide/libraries/loader.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Loader Class</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/libraries/output.html b/user_guide/libraries/output.html
index 634ae85..7c765b6 100644
--- a/user_guide/libraries/output.html
+++ b/user_guide/libraries/output.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Output Class</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/libraries/pagination.html b/user_guide/libraries/pagination.html
index e7ca83e..af21005 100644
--- a/user_guide/libraries/pagination.html
+++ b/user_guide/libraries/pagination.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Pagination Class</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/libraries/parser.html b/user_guide/libraries/parser.html
index 7715fe3..d5631ec 100644
--- a/user_guide/libraries/parser.html
+++ b/user_guide/libraries/parser.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Template Parser Class</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/libraries/sessions.html b/user_guide/libraries/sessions.html
index 8349bd4..6874499 100644
--- a/user_guide/libraries/sessions.html
+++ b/user_guide/libraries/sessions.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Session Class</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/libraries/table.html b/user_guide/libraries/table.html
index e6b6b99..1ae2d86 100644
--- a/user_guide/libraries/table.html
+++ b/user_guide/libraries/table.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : HTML Table Class</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/libraries/trackback.html b/user_guide/libraries/trackback.html
index 799c566..c5a50f0 100644
--- a/user_guide/libraries/trackback.html
+++ b/user_guide/libraries/trackback.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Trackback Class</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/libraries/unit_testing.html b/user_guide/libraries/unit_testing.html
index 3ead566..5ca982f 100644
--- a/user_guide/libraries/unit_testing.html
+++ b/user_guide/libraries/unit_testing.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Unit Testing Class</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/libraries/uri.html b/user_guide/libraries/uri.html
index bc831a2..22a5e69 100644
--- a/user_guide/libraries/uri.html
+++ b/user_guide/libraries/uri.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : URI Class</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/libraries/user_agent.html b/user_guide/libraries/user_agent.html
index 8c77088..5a5dd14 100644
--- a/user_guide/libraries/user_agent.html
+++ b/user_guide/libraries/user_agent.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : User Agent Class</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/libraries/validation.html b/user_guide/libraries/validation.html
index 3532282..b46dbc1 100644
--- a/user_guide/libraries/validation.html
+++ b/user_guide/libraries/validation.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Form Validation</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/libraries/xmlrpc.html b/user_guide/libraries/xmlrpc.html
index 5d54eca..2430656 100644
--- a/user_guide/libraries/xmlrpc.html
+++ b/user_guide/libraries/xmlrpc.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : XML-RPC and XML-RPC Server Classes</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/libraries/zip.html b/user_guide/libraries/zip.html
index f3ce200..5d0f22a 100644
--- a/user_guide/libraries/zip.html
+++ b/user_guide/libraries/zip.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Zip Encoding Class</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/license.html b/user_guide/license.html
index 0b777dd..e614a5e 100644
--- a/user_guide/license.html
+++ b/user_guide/license.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : CodeIgniter License Agreement</title>
 
 <style type='text/css' media='all'>@import url('userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='userguide.css' />
diff --git a/user_guide/overview/appflow.html b/user_guide/overview/appflow.html
index b2327f9..26868c3 100644
--- a/user_guide/overview/appflow.html
+++ b/user_guide/overview/appflow.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Application Flow Chart</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/overview/at_a_glance.html b/user_guide/overview/at_a_glance.html
index 0476362..2d662bf 100644
--- a/user_guide/overview/at_a_glance.html
+++ b/user_guide/overview/at_a_glance.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : CodeIgniter at a Glance</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/overview/features.html b/user_guide/overview/features.html
index 8ee7895..edb4cc4 100644
--- a/user_guide/overview/features.html
+++ b/user_guide/overview/features.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : CodeIgniter Features</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/overview/goals.html b/user_guide/overview/goals.html
index 8b56464..5a0b883 100644
--- a/user_guide/overview/goals.html
+++ b/user_guide/overview/goals.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Design and Architectural Goals</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/overview/index.html b/user_guide/overview/index.html
index 03b6ed0..0e96d4d 100644
--- a/user_guide/overview/index.html
+++ b/user_guide/overview/index.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : CodeIgniter Overview</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/overview/mvc.html b/user_guide/overview/mvc.html
index fe960f6..6c63eb4 100644
--- a/user_guide/overview/mvc.html
+++ b/user_guide/overview/mvc.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Model-View-Controller</title>
 
 <style type='text/css' media='all'>@import url('../userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='../userguide.css' />
diff --git a/user_guide/toc.html b/user_guide/toc.html
index b3b1b27..b08a739 100644
--- a/user_guide/toc.html
+++ b/user_guide/toc.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 
-<title>CodeIgniter User Guide</title>
+<title>CodeIgniter User Guide : Table of Contents</title>
 
 <style type='text/css' media='all'>@import url('userguide.css');</style>
 <link rel='stylesheet' type='text/css' media='all' href='userguide.css' />
